@codeyam/codeyam-cli 0.1.6 → 0.1.8

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-24T16:49:42.311Z",
-  "buildTime": 1771951782311,
-  "gitCommit": "fb5c6c43d47cae2bdd39cf0e2bfc7eb7f6a9c77e",
+  "buildTimestamp": "2026-03-03T21:38:29.205Z",
+  "buildTime": 1772573909205,
+  "gitCommit": "d6e9b191c6db7a9b47f3bf984e4387e2c0607deb",
   "nodeVersion": "v20.20.0",
-  "contentHash": "4a186f37ec4532e5a53e13c6fe2b2ce95a580cd45c739dc01a9ed7688ff1f99a",
-  "buildNumber": 674,
-  "semanticVersion": "0.1.674",
-  "version": "0.1.674 (2026-02-24T16:49+4a186f3)"
+  "contentHash": "56095f026fcf9575b86866f4fe3d3d61b9466cf70e4d3f16001752fd1febd7c2",
+  "buildNumber": 829,
+  "semanticVersion": "0.1.829",
+  "version": "0.1.829 (2026-03-03T21:38+56095f0)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/24/2026, 4:49:42 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/24/2026, 4:49:42 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[3/3/2026, 9:38:29 PM] > codeyam-combo@1.0.0 mergeDependencies
+[3/3/2026, 9:38:29 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/24/2026, 4:49:42 PM] Merged dependencies into root package.json
+[3/3/2026, 9:38:29 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
     "@aws-sdk/client-cloudfront": "^3.990.0",
-    "@aws-sdk/client-codebuild": "^3.995.0",
+    "@aws-sdk/client-codebuild": "^3.990.0",
     "@aws-sdk/client-dynamodb": "^3.990.0",
     "@aws-sdk/client-ec2": "^3.990.0",
     "@aws-sdk/client-ecr": "^3.990.0",
@@ -18,7 +18,7 @@
     "@aws-sdk/client-sqs": "^3.990.0",
     "@aws-sdk/lib-storage": "^3.990.0",
     "@aws-sdk/util-dynamodb": "^3.990.0",
-    "@octokit/auth-app": "^8.1.0",
+    "@octokit/auth-app": "^8.2.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
     "@supabase/supabase-js": "2.88.0",
@@ -44,12 +44,12 @@
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.74.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "@aws-sdk/s3-request-presigner": "^3.990.0",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
     "kysely": "^0.28.11",
-    "pg": "^8.16.3",
+    "pg": "^8.19.0",
     "@octokit/request": "^10.0.3",
     "lucide-react": "^0.556.0",
     "react-resizable": "^3.0.5"
@@ -62,7 +62,7 @@
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.18.1",
     "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",

package/analyzer-template/packages/ai/package.json

@@ -9,7 +9,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "jsdom": "^27.4.0",
     "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",

package/analyzer-template/packages/ai/src/lib/astScopes/astScopeAnalyzer.ts

@@ -909,11 +909,42 @@ export class ASTScopeAnalyzer {
     if (tsType.flags & ts.TypeFlags.Union) {
       const unionType = tsType as ts.UnionType;
 
-      // Check if it's a string literal union
-      const isAllStringLiterals = unionType.types.every(
+      // Check if it's a string literal union (optionally with null/undefined).
+      // Preserve literal values so the LLM knows which values are valid when
+      // generating mock data. Without this, types like
+      // 'suggestion' | 'warning' | 'achievement' | 'tip' become just 'string'
+      // and the LLM generates invalid values (e.g. "Motivational").
+      const stringLiterals = unionType.types.filter(
         (t) => (t.flags & ts.TypeFlags.StringLiteral) !== 0,
       );
-      if (isAllStringLiterals) return 'string';
+      const nullishTypes = unionType.types.filter(
+        (t) =>
+          (t.flags & ts.TypeFlags.Undefined) !== 0 ||
+          (t.flags & ts.TypeFlags.Null) !== 0,
+      );
+
+      if (
+        stringLiterals.length > 0 &&
+        stringLiterals.length + nullishTypes.length === unionType.types.length
+      ) {
+        const literalValues = stringLiterals.map(
+          (t) => `'${(t as ts.LiteralType).value}'`,
+        );
+        const literalUnion = literalValues.join(' | ');
+
+        if (nullishTypes.length > 0) {
+          const nullishParts: string[] = [];
+          if (nullishTypes.some((t) => (t.flags & ts.TypeFlags.Null) !== 0))
+            nullishParts.push('null');
+          if (
+            nullishTypes.some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)
+          )
+            nullishParts.push('undefined');
+          return `${literalUnion} | ${nullishParts.join(' | ')}`;
+        }
+
+        return literalUnion;
+      }
 
       // Check if it's a number literal union
       const isAllNumberLiterals = unionType.types.every(

package/analyzer-template/packages/ai/src/lib/completionCall.ts

@@ -134,7 +134,7 @@ export default async function completionCall({
   };
   const params = lib.openai.chatRequestToOpenAIChatParams(chatRequest);
 
-  const chatCompletion = await queue.add(() => {
+  const chatCompletionResult = await queue.add(() => {
     queueEndTime = Date.now();
     return PRetry(
       async () => {
@@ -185,6 +185,12 @@ export default async function completionCall({
       },
     );
   });
+
+  if (!chatCompletionResult) {
+    throw new Error('Completion call returned no result');
+  }
+
+  const chatCompletion = chatCompletionResult;
   const endTime = Date.now();
 
   const llmCallStats = getLLMCallStats({
@@ -304,7 +310,7 @@ ${completion}
 
 Please provide a corrected version with valid JSON only. Do not include any explanatory text, just the valid JSON object.`;
 
-        const correctionChatCompletion = await queue.add(() => {
+        const correctionChatCompletionResult = await queue.add(() => {
           return PRetry(
             async () => {
               const correctionStartTime = Date.now();
@@ -359,6 +365,12 @@ Please provide a corrected version with valid JSON only. Do not include any expl
           );
         });
 
+        if (!correctionChatCompletionResult) {
+          throw new Error('Correction call returned no result');
+        }
+
+        const correctionChatCompletion = correctionChatCompletionResult;
+
         const correctedRawCompletion =
           correctionChatCompletion.choices?.[0]?.message?.content;
 

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -1108,6 +1108,33 @@ export class ScopeDataStructure {
       return;
     }
 
+    // Case 3: Circular reference through scope-suffixed names (____cyScope pattern)
+    // When a named arrow function is defined inside a scope (e.g., useEffect callback):
+    //   const identifyUser = async () => { ... };
+    //   identifyUser();
+    // This creates a variable "identifyUser" and a scope "identifyUser____cyScope9F".
+    // Mutual equivalencies between these cause infinite loops in Phase 2 because
+    // processing one triggers addToSchema → followEquivalencies → addEquivalency
+    // on the reverse, which repeats indefinitely.
+    // Only block when the REVERSE direction already exists (creating a cycle).
+    // The initial one-directional equivalency is necessary for scope resolution.
+    if (
+      path &&
+      equivalentPath &&
+      (equivalentPath.startsWith(path + '____') ||
+        path.startsWith(equivalentPath + '____'))
+    ) {
+      // Check if the reverse equivalency already exists
+      const reverseEquivalencies =
+        scopeNode.equivalencies[equivalentPath] || [];
+      const reverseExists = reverseEquivalencies.some(
+        (v) => v.schemaPath === path,
+      );
+      if (reverseExists) {
+        return;
+      }
+    }
+
     if (!equivalentScopeName) {
       console.error(
         'CodeYam Error: Missing equivalent scope name - FULL CONTEXT:',

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/coercePrimitivesToArraysBySchema.ts

@@ -0,0 +1,62 @@
+/**
+ * Coerces primitive values to empty arrays when the schema expects an array.
+ *
+ * The LLM sometimes generates a primitive (boolean, number, string) where the
+ * schema expects an array. For example:
+ *   Schema: { webapps: [{ name: "string" }] }
+ *   LLM output: { webapps: true }
+ *
+ * This causes runtime errors like `TypeError: config.webapps?.forEach is not a function`
+ * because the code expects an array but gets a boolean.
+ *
+ * Coercion rule:
+ * - primitive → array: replace with []
+ *
+ * Null and undefined values are preserved (they may be intentionally nullable).
+ *
+ * @param data The mock data object to coerce (mutated in place)
+ * @param schema The schema describing expected types
+ */
+export default function coercePrimitivesToArraysBySchema<T>(
+  data: T,
+  schema: unknown,
+): T {
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = coercePrimitivesToArraysBySchema(data[i], itemSchema);
+    }
+    return data;
+  }
+
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+
+    if (value === null || value === undefined) {
+      continue;
+    }
+
+    if (typeof value !== 'object' && Array.isArray(fieldSchema)) {
+      // Schema expects an array but the value is a primitive.
+      // Replace with an empty array.
+      dataObj[key] = [];
+    } else if (typeof value === 'object' && value !== null) {
+      // Both value and schema are objects — recurse
+      coercePrimitivesToArraysBySchema(value, fieldSchema);
+    }
+  }
+
+  return data;
+}

package/analyzer-template/packages/ai/src/lib/generateEntityScenarioData.ts

@@ -19,6 +19,8 @@ import convertNullToUndefinedBySchema from './dataStructure/helpers/convertNullT
 import convertTypeAnnotationsToValues from './dataStructure/helpers/convertTypeAnnotationsToValues';
 import fixNullIdsBySchema from './dataStructure/helpers/fixNullIdsBySchema';
 import coerceObjectsToPrimitivesBySchema from './dataStructure/helpers/coerceObjectsToPrimitivesBySchema';
+import coercePrimitivesToArraysBySchema from './dataStructure/helpers/coercePrimitivesToArraysBySchema';
+import stripNullableMarkers from './dataStructure/helpers/stripNullableMarkers';
 import { JsonTypeDefinition } from '~codeyam/types';
 import { deepMerge } from '~codeyam/generate';
 import {
@@ -172,6 +174,46 @@ function findKeyPath(
   return null;
 }
 
+/**
+ * Strip primitive values from `source` when the `destination` already has an
+ * array or object at the same key. Returns a cleaned copy of source (or null
+ * if nothing remains after stripping).
+ *
+ * This prevents misplaced LLM data (e.g., `{ webapps: true }`) from
+ * overwriting correct complex values (e.g., `{ webapps: [...] }`) during
+ * deep merge in relocateMisplacedNestedKeys.
+ */
+function stripPrimitivesOverwritingComplexValues(
+  destination: Record<string, unknown>,
+  source: unknown,
+): Record<string, unknown> | null {
+  if (typeof source !== 'object' || source === null || Array.isArray(source)) {
+    return null;
+  }
+
+  const result: Record<string, unknown> = {};
+  let hasKeys = false;
+
+  for (const key of Object.keys(source as Record<string, unknown>)) {
+    const srcVal = (source as Record<string, unknown>)[key];
+    const dstVal = destination[key];
+
+    // If destination has an array or object but source has a primitive, skip it
+    if (
+      typeof dstVal === 'object' &&
+      dstVal !== null &&
+      typeof srcVal !== 'object'
+    ) {
+      continue;
+    }
+
+    result[key] = srcVal;
+    hasKeys = true;
+  }
+
+  return hasKeys ? result : null;
+}
+
 /**
  * Relocate misplaced nested keys in mockData to their correct position
  * based on the dataForMocks structure.
@@ -233,12 +275,22 @@ function relocateMisplacedNestedKeys(
     }
 
     // Deep merge the value into the correct location
-    // Use deep merge to preserve existing data at that location
+    // Use deep merge to preserve existing data at that location.
+    // Before merging, strip primitives from the misplaced value that would
+    // overwrite arrays/objects at the destination. The misplaced data is lower
+    // quality — the LLM put it in the wrong place — so primitives like `true`
+    // should not overwrite correct complex values like arrays.
     if (current[key] !== undefined && typeof current[key] === 'object') {
-      current[key] = deepMerge(
+      const safeValue = stripPrimitivesOverwritingComplexValues(
         current[key] as Record<string, unknown>,
         value as Record<string, unknown>,
       );
+      if (safeValue !== null) {
+        current[key] = deepMerge(
+          current[key] as Record<string, unknown>,
+          safeValue,
+        );
+      }
     } else {
       current[key] = value;
     }
@@ -1063,6 +1115,18 @@ export async function generateDataForScenario({
     );
   }
 
+  // Strip _nullable markers from LLM-generated mock data.
+  // The _nullable marker is an internal CodeYam concept used in type definitions
+  // to indicate that a field can be null/undefined. The LLM sometimes includes
+  // these markers in its generated data, which causes runtime errors when code
+  // iterates over object keys (e.g., Object.keys(importedBy) picks up "_nullable",
+  // then Object.keys(importedBy["_nullable"]) calls Object.keys(null) and throws).
+  if (fullScenarioData.data.mockData) {
+    stripNullableMarkers(
+      fullScenarioData.data.mockData as Record<string, unknown>,
+    );
+  }
+
   // Relocate misplaced nested keys to their correct position.
   // The LLM sometimes places nested keys at root level instead of inside their
   // parent object (e.g., 'fastener' at root instead of inside 'trpc').
@@ -1098,6 +1162,18 @@ export async function generateDataForScenario({
     );
   }
 
+  // Coerce primitives to empty arrays when the schema expects an array.
+  // The LLM sometimes generates a primitive (e.g., `webapps: true`) where the
+  // schema expects an array (e.g., `webapps: [{ name: "string" }]`).
+  // This causes runtime errors like "TypeError: config.webapps?.forEach is not a function".
+  // Must run AFTER coerceObjectsToPrimitivesBySchema and BEFORE convertCommaSeparatedStringsToArrays.
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    coercePrimitivesToArraysBySchema(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
   // Convert comma-separated strings to arrays when appropriate.
   // The LLM sometimes generates strings like "color,size" instead of arrays
   // like ["color", "size"] when the schema type is incorrectly inferred as

package/analyzer-template/packages/analyze/src/lib/ProjectAnalyzer.ts

@@ -46,6 +46,12 @@ export class ProjectAnalyzer {
       lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
     );
 
+    if (this.programs.length === 0) {
+      throw new Error(
+        'No TypeScript programs could be created — no tsconfig.json found',
+      );
+    }
+
     // Primary program is the first one (usually root) for backward compatibility
     this.program = this.programs[0];
     this.typeChecker = this.program.getTypeChecker();

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities.ts

@@ -310,7 +310,15 @@ export default async function analyzeEntities({
   );
 
   // Flush transformation trace if tracing is enabled
-  transformationTracer.flush();
+  // Wrapped in try/catch because trace data can exceed V8's max string length
+  // for large projects, and we must not crash the analysis process over tracing.
+  try {
+    transformationTracer.flush();
+  } catch (e) {
+    console.warn(
+      `CodeYam Warning: Failed to flush transformation trace: ${e.message}`,
+    );
+  }
 
   return analyses;
 

package/analyzer-template/packages/analyze/src/lib/files/analyze/dependencyResolver.ts

@@ -100,12 +100,6 @@ export function getCandidatesReadyForCapture(
       continue;
     }
 
-    // Skip notExported entities - they can't be imported into the simulation
-    // environment and will always fail capture. Don't mark them as ready.
-    if (candidate.entity?.metadata?.notExported) {
-      continue;
-    }
-
     // Get all transitive dependencies
     const candidateKey = `${candidate.filePath}:${candidate.entityName}`;
     const { missingDependencies } = getTransitiveDependencies(

package/analyzer-template/packages/analyze/src/lib/files/analyze/findOrCreateEntity.ts

@@ -138,6 +138,18 @@ export default async function findOrCreateEntity({
           break;
         }
       }
+
+      // Mark previous versions as superseded
+      const entitiesToSupersede = previousEntities.filter(
+        (e) => !e.metadata?.isSuperseded,
+      );
+      if (entitiesToSupersede.length > 0) {
+        for (const prev of entitiesToSupersede) {
+          prev.metadata = prev.metadata || {};
+          prev.metadata.isSuperseded = true;
+        }
+        await upsertEntities(entitiesToSupersede);
+      }
     }
 
     entity = {

package/analyzer-template/packages/analyze/src/lib/files/scenarios/TransformationTracer.ts

@@ -404,22 +404,15 @@ export class TransformationTracer {
   }
 
   /**
-   * Write the trace to the output file.
+   * Compute the summary data for the current traces.
    */
-  flush(): void {
-    if (!this.isEnabled()) return;
-    if (this.traces.size === 0) {
-      this.log('flush: no traces to write');
-      return;
-    }
-
-    const entities = Array.from(this.traces.keys());
-    const stageCounts = entities
-      .map((e) => `${e}(${this.traces.get(e)!.stages.length})`)
-      .join(', ');
-    this.log(`flush: writing ${entities.length} entities: ${stageCounts}`);
-
-    // Compute summary
+  private computeFlushSummary(): {
+    stageChangeCounts: Record<
+      string,
+      { added: number; removed: number; changed: number }
+    >;
+    entitiesWithMostChanges: string[];
+  } {
     const stageChangeCounts: Record<
       string,
       { added: number; removed: number; changed: number }
@@ -484,17 +477,39 @@ export class TransformationTracer {
       .slice(0, 10)
       .map(([name]) => name);
 
-    const traceFile: TraceFile = {
-      meta: {
-        timestamp: new Date().toISOString(),
-        projectSlug: this.projectSlug,
-        entityCount: this.traces.size,
-      },
-      summary: {
-        stageChangeCounts,
-        entitiesWithMostChanges,
-      },
-      entities: Object.fromEntries(this.traces),
+    return { stageChangeCounts, entitiesWithMostChanges };
+  }
+
+  /**
+   * Write the trace to the output file.
+   * Uses streaming per-entity writes to avoid exceeding V8's max string length
+   * on large projects.
+   */
+  flush(): void {
+    if (!this.isEnabled()) return;
+    if (this.traces.size === 0) {
+      this.log('flush: no traces to write');
+      return;
+    }
+
+    const entities = Array.from(this.traces.keys());
+    const stageCounts = entities
+      .map((e) => `${e}(${this.traces.get(e)!.stages.length})`)
+      .join(', ');
+    this.log(`flush: writing ${entities.length} entities: ${stageCounts}`);
+
+    const { stageChangeCounts, entitiesWithMostChanges } =
+      this.computeFlushSummary();
+
+    const meta = {
+      timestamp: new Date().toISOString(),
+      projectSlug: this.projectSlug,
+      entityCount: this.traces.size,
+    };
+
+    const summary = {
+      stageChangeCounts,
+      entitiesWithMostChanges,
     };
 
     // Ensure directory exists
@@ -503,8 +518,30 @@ export class TransformationTracer {
       fs.mkdirSync(dir, { recursive: true });
     }
 
-    fs.writeFileSync(this.outputPath, JSON.stringify(traceFile, null, 2));
-    this.log(`flush: wrote trace to ${this.outputPath}`);
+    // Stream JSON per-entity to avoid exceeding V8's max string length.
+    // Each entity is serialized individually so no single JSON.stringify
+    // call needs to produce the entire trace.
+    const fd = fs.openSync(this.outputPath, 'w');
+    try {
+      fs.writeSync(fd, '{\n  "meta": ');
+      fs.writeSync(fd, JSON.stringify(meta, null, 2));
+      fs.writeSync(fd, ',\n  "summary": ');
+      fs.writeSync(fd, JSON.stringify(summary, null, 2));
+      fs.writeSync(fd, ',\n  "entities": {');
+
+      let first = true;
+      for (const [entityName, entityTrace] of this.traces) {
+        if (!first) fs.writeSync(fd, ',');
+        fs.writeSync(fd, `\n    ${JSON.stringify(entityName)}: `);
+        fs.writeSync(fd, JSON.stringify(entityTrace, null, 2));
+        first = false;
+      }
+
+      fs.writeSync(fd, '\n  }\n}\n');
+      this.log(`flush: wrote trace to ${this.outputPath}`);
+    } finally {
+      fs.closeSync(fd);
+    }
   }
 
   /**

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateDataStructure.ts

@@ -461,6 +461,17 @@ export default function generateDataStructure({
 
     const { isolatedDataStructure } = entity.metadata;
 
+    if (!isolatedDataStructure) {
+      awsLog(
+        'CodeYam: Skipping data structure generation — isolatedDataStructure is undefined (scope analysis may have failed)',
+        {
+          entityName: entity.name,
+          filePath: entity.filePath,
+        },
+      );
+      return analysis;
+    }
+
     // Transformation tracing: start entity and capture isolated data structure
     transformationTracer.startEntity({
       name: entity.name,
@@ -643,6 +654,78 @@ export default function generateDataStructure({
           },
         );
 
+        // Infer function types from child component usage BEFORE fillInSchemaGapsAndUnknowns.
+        // When a hook returns a property with type 'unknown' that is passed to a child
+        // component which calls it as a function (e.g., isEntityPending(entity)),
+        // promote it to 'function'. Without this, name heuristics like isLikelyBoolean
+        // would mistype "isEntityPending" as boolean because of the "is" prefix.
+        //
+        // sourceEquivalencies are in isolatedDataStructure.dependencySchemas (not in
+        // mergedDataStructure.dependencySchemas — they're dropped during the merge).
+        // The child's signatureSchema (with function call evidence) IS in the merged schemas.
+        {
+          const isolatedDepSchemas =
+            entity.metadata.isolatedDataStructure?.dependencySchemas;
+          if (isolatedDepSchemas) {
+            for (const childFilePath in isolatedDepSchemas) {
+              const childIsolated = isolatedDepSchemas[childFilePath];
+              for (const childName in childIsolated) {
+                const sourceEq = childIsolated[childName]?.sourceEquivalencies;
+                if (!sourceEq) continue;
+
+                // Get the child's signatureSchema from the MERGED schemas (richer)
+                const mergedChildSchema =
+                  mergedDataStructure.dependencySchemas[childFilePath]?.[
+                    childName
+                  ];
+                const sigSchema = mergedChildSchema?.signatureSchema;
+                if (!sigSchema) continue;
+
+                for (const childPath in sourceEq) {
+                  for (const source of sourceEq[childPath]) {
+                    const fcrvSuffix = '.functionCallReturnValue.';
+                    const fcrvIndex = source.schemaPath.indexOf(fcrvSuffix);
+                    if (fcrvIndex === -1) continue;
+
+                    const propName = source.schemaPath.slice(
+                      fcrvIndex + fcrvSuffix.length,
+                    );
+
+                    // Find the corresponding child signature path
+                    const entityCallPrefix = childName + '().';
+                    const sigPathBase = childPath.startsWith(entityCallPrefix)
+                      ? childPath.slice(entityCallPrefix.length)
+                      : childPath;
+
+                    // Check if the child's signatureSchema has a function call version
+                    let isFunction = false;
+                    for (const sigKey in sigSchema) {
+                      if (
+                        sigKey.startsWith(sigPathBase + '(') &&
+                        sigSchema[sigKey] === 'function'
+                      ) {
+                        isFunction = true;
+                        break;
+                      }
+                    }
+
+                    if (isFunction) {
+                      for (const rvKey in depSchema.returnValueSchema) {
+                        if (
+                          rvKey.endsWith('.' + propName) &&
+                          depSchema.returnValueSchema[rvKey] === 'unknown'
+                        ) {
+                          depSchema.returnValueSchema[rvKey] = 'function';
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+
         // Fill in type gaps BEFORE clearing attributes, so evidence like .includes()
         // is used for type inference before being deleted